However, this is actually a rather interesting side effect of PAWN's ancestory: C.

In C, arrays and pointers (which hold an address which "points" to a place in memory) are the same. T
herefore, a way to "slice" strings easily is to just give up the address to the point in the array you want to start at.

For example, if we have an array of five cells, it is in memory like so:

cell 1 (offset 0) <- pointer A
cell 2 (offset 1)
cell 3 (offset 2)
cell 4 (offset 3)
cell 5 (offset 4)

This is the reason when we index an array, it starts at 0; we really just take the start of the array 
and do an add and multiply to get to the point we want (0 therefore does nothing as anything multiplied by zero is zero).

Pointer A points to the first element in the array. 
If we want to "slice" the string a bit, say to get the string between cell 3 and 5, we can just use the pointer and add 8 to it 
(2 elements * 4 (size of a cell in memory) ).

This is how C arrays work; how do PAWN arrays work? 
Same exact way, but we don't have pointers (as you can see above, pointers can make your head hurt). 
Yet, we get the same semantics for string slicing. How is this?

In PAWN (and C), all arrays (including strings) are passed by reference, IE, a pointer to the string is passed. 
This is why arrays modified in a called function stay modified. 
In addition, all the array index syntax ([num]) does is do the multiply and add for you 
(the name of the array is actually just a hidden pointer to the first element in the array). 
USUALLY, it ALSO takes the pointer and returns what it points to (called dereferencing). 
This is good for us; we don't want to deal with pointers.

HOWEVER, in PAWN, we can't do stuff concerning the NAME of the array, because we don't have pointers like C. 
So, when you PASS an array, you don't want it to dereference the pointer (otherwise you aren't passing an array, you are just passing the first element!),  
and you also don't want it to give an error, so it handles it correctly (passes it as a pointer, not an index into the array). 
But when you put in an index anyway (array[4]), you are still doing the multiply and addition, but it is also converting it into a pointer. 
The upshot is, it lets you return the index of the array as if it was the START of the array.